package com.gitee.huanminabc.utils_tools.zk;

import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;
import org.springframework.util.StringUtils;

import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

/**
 * Zookeeper 工具类
 * 提供完整的 ZK 节点操作功能，监听器管理委托给 ZookeeperWatcherManager
 *
 * @author sby
 * @since 1.0.0
 */
@Slf4j
@Data
public class ZookeeperUtil {

    private ZooKeeper zooKeeper;
    private String connectString;
    private int sessionTimeout = 30000;
    private int connectionTimeout = 10000;
    
    // 监听器管理器
    private ZookeeperWatcherManager watcherManager;
    
    /**
     * 默认构造函数
     */
    public ZookeeperUtil() {
    }
    
    /**
     * 构造函数
     *
     * @param connectString ZK 连接字符串
     */
    public ZookeeperUtil(String connectString) {
        this();
        this.connectString = connectString;
    }
    
    /**
     * 构造函数
     *
     * @param connectString     ZK 连接字符串
     * @param sessionTimeout    会话超时时间
     * @param connectionTimeout 连接超时时间
     */
    public ZookeeperUtil(String connectString, int sessionTimeout, int connectionTimeout) {
        this.connectString = connectString;
        this.sessionTimeout = sessionTimeout;
        this.connectionTimeout = connectionTimeout;
    }
    
    /**
     * 连接到 Zookeeper
     *
     * @return 是否连接成功
     */
    public boolean connect() {
        return connect(this.connectString);
    }
    
    /**
     * 连接到 Zookeeper
     *
     * @param connectString ZK 连接字符串
     * @return 是否连接成功
     */
    public boolean connect(String connectString) {
        if (StringUtils.isEmpty(connectString)) {
            log.error("Zookeeper 连接字符串不能为空");
            return false;
        }
        
        try {
            CountDownLatch latch = new CountDownLatch(1);
            
            this.zooKeeper = new ZooKeeper(connectString, sessionTimeout, event -> {
                if (event.getState() == Watcher.Event.KeeperState.SyncConnected) {
                    log.info("Zookeeper 连接成功: {}", connectString);
                    latch.countDown();
                }
            });
            
            // 等待连接建立
            boolean connected = latch.await(connectionTimeout, TimeUnit.MILLISECONDS);
            if (!connected) {
                log.error("Zookeeper 连接超时: {}", connectString);
                return false;
            }
            
            this.connectString = connectString;
            
            // 初始化监听器管理器
            this.watcherManager = new ZookeeperWatcherManager(this.zooKeeper, this);
            
            return true;
            
        } catch (Exception e) {
            log.error("Zookeeper 连接失败: {}", connectString, e);
            return false;
        }
    }
    
    /**
     * 断开连接
     */
    public void disconnect() {
        if (zooKeeper != null) {
            try {
                // 清理所有可持续监听器
                if (watcherManager != null) {
                    watcherManager.removeAllPersistentWatchers();
                }
                
                zooKeeper.close();
                log.info("Zookeeper 连接已断开");
            } catch (InterruptedException e) {
                log.error("断开 Zookeeper 连接时发生异常", e);
                Thread.currentThread().interrupt();
            } finally {
                zooKeeper = null;
                watcherManager = null;
            }
        }
    }
    
    /**
     * 检查连接状态
     *
     * @return 是否已连接
     */
    public boolean isConnected() {
        return zooKeeper != null && zooKeeper.getState() == ZooKeeper.States.CONNECTED;
    }
    
    /**
     * 创建节点
     *
     * @param path 节点路径
     * @param data 节点数据
     * @return 是否创建成功
     */
    public boolean createNode(String path, String data) {
        return createNode(path, data, CreateMode.PERSISTENT);
    }
    
    /**
     * 创建节点
     *
     * @param path      节点路径
     * @param data      节点数据
     * @param createMode 创建模式
     * @return 是否创建成功
     */
    public boolean createNode(String path, String data, CreateMode createMode) {
        if (!isConnected()) {
            log.error("Zookeeper 未连接");
            return false;
        }
        
        try {
            byte[] bytes = data != null ? data.getBytes() : new byte[0];
            String createdPath = zooKeeper.create(path, bytes, ZooDefs.Ids.OPEN_ACL_UNSAFE, createMode);
            log.info("节点创建成功: {}", createdPath);
            return true;
        } catch (KeeperException.NodeExistsException e) {
            log.warn("节点已存在: {}", path);
            return true;
        } catch (Exception e) {
            log.error("创建节点失败: {}", path, e);
            return false;
        }
    }
    
    /**
     * 创建临时节点
     *
     * @param path 节点路径
     * @param data 节点数据
     * @return 是否创建成功
     */
    public boolean createEphemeralNode(String path, String data) {
        return createNode(path, data, CreateMode.EPHEMERAL);
    }
    
    /**
     * 创建顺序节点
     *
     * @param path 节点路径
     * @param data 节点数据
     * @return 是否创建成功
     */
    public boolean createSequentialNode(String path, String data) {
        return createNode(path, data, CreateMode.PERSISTENT_SEQUENTIAL);
    }
    
    /**
     * 获取节点数据
     *
     * @param path 节点路径
     * @return 节点数据
     */
    public String getNodeData(String path) {
        if (!isConnected()) {
            log.error("Zookeeper 未连接");
            return null;
        }
        
        try {
            byte[] data = zooKeeper.getData(path, false, null);
            return data != null ? new String(data) : null;
        } catch (KeeperException.NoNodeException e) {
            log.warn("节点不存在: {}", path);
            return null;
        } catch (Exception e) {
            log.error("获取节点数据失败: {}", path, e);
            return null;
        }
    }
    
    /**
     * 获取节点数据（带监听器）
     *
     * @param path      节点路径
     * @param watcher   监听器
     * @return 节点数据
     */
    public String getNodeData(String path, Watcher watcher) {
        if (!isConnected()) {
            log.error("Zookeeper 未连接");
            return null;
        }
        
        try {
            byte[] data = zooKeeper.getData(path, watcher, null);
            return data != null ? new String(data) : null;
        } catch (KeeperException.NoNodeException e) {
            log.warn("节点不存在: {}", path);
            return null;
        } catch (Exception e) {
            log.error("获取节点数据失败: {}", path, e);
            return null;
        }
    }
    
    /**
     * 设置节点数据
     *
     * @param path 节点路径
     * @param data 节点数据
     * @return 是否设置成功
     */
    public boolean setNodeData(String path, String data) {
        if (!isConnected()) {
            log.error("Zookeeper 未连接");
            return false;
        }
        
        try {
            byte[] bytes = data != null ? data.getBytes() : new byte[0];
            Stat stat = zooKeeper.setData(path, bytes, -1);
            log.info("节点数据设置成功: {}, version: {}", path, stat.getVersion());
            return true;
        } catch (KeeperException.NoNodeException e) {
            log.error("节点不存在: {}", path);
            return false;
        } catch (Exception e) {
            log.error("设置节点数据失败: {}", path, e);
            return false;
        }
    }
    
    /**
     * 设置节点数据，如果节点不存在则创建（UPSERT 操作）
     *
     * @param path 节点路径
     * @param data 节点数据
     * @return 是否操作成功
     */
    public boolean setNodeDataOrCreate(String path, String data) {
        return setNodeDataOrCreate(path, data, CreateMode.PERSISTENT);
    }
    
    /**
     * 设置节点数据，如果节点不存在则创建（UPSERT 操作，支持版本号）
     *
     * @param path 节点路径
     * @param data 节点数据
     * @param version 节点版本号（-1 表示忽略版本）
     * @return 是否操作成功
     */
    public boolean setNodeDataOrCreate(String path, String data, int version) {
        if (!isConnected()) {
            log.error("Zookeeper 未连接");
            return false;
        }
        
        try {
            // 先尝试设置数据（节点存在的情况）
            byte[] bytes = data != null ? data.getBytes() : new byte[0];
            Stat stat = zooKeeper.setData(path, bytes, version);
            log.info("节点数据更新成功: {}, version: {}", path, stat.getVersion());
            return true;
        } catch (KeeperException.NoNodeException e) {
            // 节点不存在，创建新节点
            log.info("节点不存在，开始创建: {}", path);
            try {
                if (createNodeRecursive(path, data)) {
                    log.info("节点创建并设置数据成功: {}", path);
                    return true;
                } else {
                    log.error("节点创建失败: {}", path);
                    return false;
                }
            } catch (Exception createException) {
                log.error("创建节点时发生异常: {}", path, createException);
                return false;
            }
        } catch (KeeperException.BadVersionException e) {
            log.error("节点版本不匹配: {}, version: {}", path, version);
            return false;
        } catch (Exception e) {
            log.error("设置节点数据失败: {}", path, e);
            return false;
        }
    }
    
    /**
     * 设置节点数据，如果节点不存在则创建（UPSERT 操作）
     *
     * @param path 节点路径
     * @param data 节点数据
     * @param createMode 创建模式
     * @return 是否操作成功
     */
    public boolean setNodeDataOrCreate(String path, String data, CreateMode createMode) {
        if (!isConnected()) {
            log.error("Zookeeper 未连接");
            return false;
        }
        
        try {
            // 先尝试设置数据（节点存在的情况）
            byte[] bytes = data != null ? data.getBytes() : new byte[0];
            Stat stat = zooKeeper.setData(path, bytes, -1);
            log.info("节点数据更新成功: {}, version: {}", path, stat.getVersion());
            return true;
        } catch (KeeperException.NoNodeException e) {
            // 节点不存在，创建新节点
            log.info("节点不存在，开始创建: {}", path);
            try {
                // 注意：createNodeRecursive 不支持 CreateMode，使用默认的 PERSISTENT 模式
                if (createNodeRecursive(path, data)) {
                    log.info("节点创建并设置数据成功: {}", path);
                    return true;
                } else {
                    log.error("节点创建失败: {}", path);
                    return false;
                }
            } catch (Exception createException) {
                log.error("创建节点时发生异常: {}", path, createException);
                return false;
            }
        } catch (Exception e) {
            log.error("设置节点数据失败: {}", path, e);
            return false;
        }
    }
    
    /**
     * 设置节点数据，如果节点不存在则创建（UPSERT 操作，支持指定创建模式）
     * 注意：此方法会递归创建父节点，但父节点都使用 PERSISTENT 模式
     *
     * @param path 节点路径
     * @param data 节点数据
     * @param createMode 创建模式（仅对目标节点有效）
     * @return 是否操作成功
     */
    public boolean setNodeDataOrCreateWithMode(String path, String data, CreateMode createMode) {
        if (!isConnected()) {
            log.error("Zookeeper 未连接");
            return false;
        }
        
        try {
            // 先尝试设置数据（节点存在的情况）
            byte[] bytes = data != null ? data.getBytes() : new byte[0];
            Stat stat = zooKeeper.setData(path, bytes, -1);
            log.info("节点数据更新成功: {}, version: {}", path, stat.getVersion());
            return true;
        } catch (KeeperException.NoNodeException e) {
            // 节点不存在，创建新节点
            log.info("节点不存在，开始创建: {}", path);
            try {
                // 先递归创建父节点（使用 PERSISTENT 模式）
                String parentPath = getParentPath(path);
                if (!StringUtils.isEmpty(parentPath) && !exists(parentPath)) {
                    if (!createNodeRecursive(parentPath, "")) {
                        return false;
                    }
                }
                
                // 创建目标节点（使用指定的创建模式）
                if (createNode(path, data, createMode)) {
                    log.info("节点创建并设置数据成功: {}, mode: {}", path, createMode);
                    return true;
                } else {
                    log.error("节点创建失败: {}", path);
                    return false;
                }
            } catch (Exception createException) {
                log.error("创建节点时发生异常: {}", path, createException);
                return false;
            }
        } catch (Exception e) {
            log.error("设置节点数据失败: {}", path, e);
            return false;
        }
    }
    
    /**
     * 删除节点
     *
     * @param path 节点路径
     * @return 是否删除成功
     */
    public boolean deleteNode(String path) {
        return deleteNode(path, -1);
    }
    
    /**
     * 删除节点
     *
     * @param path   节点路径
     * @param version 节点版本
     * @return 是否删除成功
     */
    public boolean deleteNode(String path, int version) {
        if (!isConnected()) {
            log.error("Zookeeper 未连接");
            return false;
        }
        
        try {
            zooKeeper.delete(path, version);
            log.info("节点删除成功: {}", path);
            return true;
        } catch (KeeperException.NoNodeException e) {
            log.warn("节点不存在: {}", path);
            return true;
        } catch (Exception e) {
            log.error("删除节点失败: {}", path, e);
            return false;
        }
    }
    
    /**
     * 检查节点是否存在
     *
     * @param path 节点路径
     * @return 节点是否存在
     */
    public boolean exists(String path) {
        if (!isConnected()) {
            log.error("Zookeeper 未连接");
            return false;
        }
        
        try {
            Stat stat = zooKeeper.exists(path, false);
            return stat != null;
        } catch (Exception e) {
            log.error("检查节点是否存在失败: {}", path, e);
            return false;
        }
    }
    
    /**
     * 获取节点状态信息
     *
     * @param path 节点路径
     * @return 节点状态
     */
    public Stat getNodeStat(String path) {
        if (!isConnected()) {
            log.error("Zookeeper 未连接");
            return null;
        }
        
        try {
            return zooKeeper.exists(path, false);
        } catch (Exception e) {
            log.error("获取节点状态失败: {}", path, e);
            return null;
        }
    }
    
    /**
     * 获取子节点列表
     *
     * @param path 节点路径
     * @return 子节点列表
     */
    public List<String> getChildren(String path) {
        if (!isConnected()) {
            log.error("Zookeeper 未连接");
            return null;
        }
        
        try {
            return zooKeeper.getChildren(path, false);
        } catch (KeeperException.NoNodeException e) {
            log.warn("节点不存在: {}", path);
            return null;
        } catch (Exception e) {
            log.error("获取子节点列表失败: {}", path, e);
            return null;
        }
    }
    
    /**
     * 获取子节点列表（带监听器）
     *
     * @param path     节点路径
     * @param watcher  监听器
     * @return 子节点列表
     */
    public List<String> getChildren(String path, Watcher watcher) {
        if (!isConnected()) {
            log.error("Zookeeper 未连接");
            return null;
        }
        
        try {
            return zooKeeper.getChildren(path, watcher);
        } catch (KeeperException.NoNodeException e) {
            log.warn("节点不存在: {}", path);
            return null;
        } catch (Exception e) {
            log.error("获取子节点列表失败: {}", path, e);
            return null;
        }
    }
    
    /**
     * 递归创建节点（如果父节点不存在则创建）
     *
     * @param path 节点路径
     * @param data 节点数据
     * @return 是否创建成功
     */
    public boolean createNodeRecursive(String path, String data) {
        if (!isConnected()) {
            log.error("Zookeeper 未连接");
            return false;
        }
        
        try {
            // 检查节点是否已存在
            if (exists(path)) {
                log.info("节点已存在: {}", path);
                return true;
            }
            
            // 创建父节点
            String parentPath = getParentPath(path);
            if (!StringUtils.isEmpty(parentPath) && !exists(parentPath)) {
                if (!createNodeRecursive(parentPath, "")) {
                    return false;
                }
            }
            
            // 创建当前节点
            return createNode(path, data);
            
        } catch (Exception e) {
            log.error("递归创建节点失败: {}", path, e);
            return false;
        }
    }
    
    /**
     * 获取父节点路径
     *
     * @param path 节点路径
     * @return 父节点路径
     */
    private String getParentPath(String path) {
        if (StringUtils.isEmpty(path) || "/".equals(path)) {
            return null;
        }
        
        int lastSlashIndex = path.lastIndexOf('/');
        if (lastSlashIndex <= 0) {
            return "/";
        }
        
        return path.substring(0, lastSlashIndex);
    }
    
    // ==================== 监听器管理委托方法 ====================
    
    /**
     * 获取监听器管理器
     *
     * @return 监听器管理器
     */
    public ZookeeperWatcherManager getWatcherManager() {
        return watcherManager;
    }
    
    // ==================== 节点监听器方法 ====================
    
    /**
     * 一次性监听节点变化（触发后失效，需要手动重新注册）
     *
     * @param path     节点路径
     * @param watcher  监听器
     * @return 是否添加成功
     */
    public boolean watchNodeOneTime(String path, Watcher watcher) {
        return addWatcher(path, watcher, "");
    }
    
    /**
     * 一次性监听节点变化（如果节点不存在则创建）
     *
     * @param path     节点路径
     * @param watcher  监听器
     * @param data     节点数据（如果节点不存在时创建）
     * @return 是否添加成功
     */
    public boolean watchNodeOneTime(String path, Watcher watcher, String data) {
        return addWatcher(path, watcher, data);
    }
    
    /**
     * 可持续监听节点变化（自动重新注册，持续有效）
     *
     * @param path     节点路径
     * @param userWatcher 用户自定义监听器
     * @param data     节点数据（如果节点不存在时创建）
     * @return 是否添加成功
     */
    public boolean watchNodePersistent(String path, Watcher userWatcher, String data) {
        return watcherManager != null && watcherManager.watchNode(path, userWatcher, data);
    }
    
    /**
     * 可持续监听节点变化（自动创建空节点）
     *
     * @param path     节点路径
     * @param userWatcher 用户自定义监听器
     * @return 是否添加成功
     */
    public boolean watchNodePersistent(String path, Watcher userWatcher) {
        return watchNodePersistent(path, userWatcher, "");
    }
    
    // ==================== 子节点监听器方法 ====================
    
    /**
     * 一次性监听子节点变化（触发后失效，需要手动重新注册）
     *
     * @param path     节点路径
     * @param watcher  监听器
     * @return 是否添加成功
     */
    public boolean watchChildrenOneTime(String path, Watcher watcher) {
        return addChildrenWatcher(path, watcher, "");
    }
    
    /**
     * 一次性监听子节点变化（如果节点不存在则创建）
     *
     * @param path     节点路径
     * @param watcher  监听器
     * @param data     节点数据（如果节点不存在时创建）
     * @return 是否添加成功
     */
    public boolean watchChildrenOneTime(String path, Watcher watcher, String data) {
        return addChildrenWatcher(path, watcher, data);
    }
    
    /**
     * 可持续监听子节点变化（自动重新注册，持续有效）
     *
     * @param path     节点路径
     * @param userWatcher 用户自定义监听器
     * @param data     节点数据（如果节点不存在时创建）
     * @return 是否添加成功
     */
    public boolean watchChildrenPersistent(String path, Watcher userWatcher, String data) {
        return watcherManager != null && watcherManager.watchChildren(path, userWatcher, data);
    }
    
    /**
     * 可持续监听子节点变化（自动创建空节点）
     *
     * @param path     节点路径
     * @param userWatcher 用户自定义监听器
     * @return 是否添加成功
     */
    public boolean watchChildrenPersistent(String path, Watcher userWatcher) {
        return watchChildrenPersistent(path, userWatcher, "");
    }
    
    // ==================== 数据变化监听器方法 ====================
    
    /**
     * 一次性监听数据变化（触发后失效，需要手动重新注册）
     *
     * @param path 节点路径
     * @param callback 数据变化回调
     * @return 是否添加成功
     */
    public boolean watchDataChangeOneTime(String path, DataChangeCallback callback) {
        return watchDataChangeOneTime(path, callback, "");
    }
    
    /**
     * 一次性监听数据变化（如果节点不存在则创建）
     *
     * @param path 节点路径
     * @param callback 数据变化回调
     * @param initialData 初始数据
     * @return 是否添加成功
     */
    public boolean watchDataChangeOneTime(String path, DataChangeCallback callback, String initialData) {
        // 创建一次性数据变化监听器
        Watcher dataWatcher = new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                if (event.getType() == Event.EventType.NodeDataChanged) {
                    try {
                        String newData = getNodeData(path);
                        callback.onDataChanged(path, null, newData);
                    } catch (Exception e) {
                        log.error("处理一次性数据变化事件失败: {}", path, e);
                    }
                }
            }
        };
        return addWatcher(path, dataWatcher, initialData);
    }
    
    /**
     * 可持续监听数据变化（自动重新注册，持续有效）
     *
     * @param path 节点路径
     * @param dataChangeHandler 数据变化处理器
     * @param data 初始节点数据（如果节点不存在时创建）
     * @return 是否添加成功
     */
    public boolean watchDataChangePersistent(String path, DataChangeHandler dataChangeHandler, String data) {
        // 转换为监听器管理器的接口类型
        ZookeeperWatcherManager.DataChangeHandler managerHandler = new ZookeeperWatcherManager.DataChangeHandler() {
            @Override
            public void onDataChanged(String path, String oldData, String newData) {
                dataChangeHandler.onDataChanged(path, oldData, newData);
            }
            
            @Override
            public String getLastData() {
                return dataChangeHandler.getLastData();
            }
            
            @Override
            public void setLastData(String data) {
                dataChangeHandler.setLastData(data);
            }
        };
        return watcherManager != null && watcherManager.watchDataChange(path, managerHandler, data);
    }
    
    /**
     * 可持续监听数据变化（自动创建空节点）
     *
     * @param path 节点路径
     * @param dataChangeHandler 数据变化处理器
     * @return 是否添加成功
     */
    public boolean watchDataChangePersistent(String path, DataChangeHandler dataChangeHandler) {
        return watchDataChangePersistent(path, dataChangeHandler, "");
    }
    
    /**
     * 可持续监听数据变化并执行回调（自动重新注册，持续有效）
     *
     * @param path 节点路径
     * @param callback 数据变化回调
     * @param initialData 初始数据
     * @return 是否添加成功
     */
    public boolean watchDataChangeWithCallback(String path, DataChangeCallback callback, String initialData) {
        // 转换为监听器管理器的接口类型
        ZookeeperWatcherManager.DataChangeCallback managerCallback = new ZookeeperWatcherManager.DataChangeCallback() {
            @Override
            public void onDataChanged(String path, String oldData, String newData) {
                callback.onDataChanged(path, oldData, newData);
            }
        };
        return watcherManager != null && watcherManager.watchDataChangeWithCallback(path, managerCallback, initialData);
    }
    
    /**
     * 可持续监听数据变化并执行回调（自动创建空节点）
     *
     * @param path 节点路径
     * @param callback 数据变化回调
     * @return 是否添加成功
     */
    public boolean watchDataChangeWithCallback(String path, DataChangeCallback callback) {
        return watchDataChangeWithCallback(path, callback, "");
    }
    

    
    // ==================== 便捷方法 ====================
    
    /**
     * 可持续监听节点变化并自动创建节点
     *
     * @param path     节点路径
     * @param userWatcher 用户自定义监听器
     * @param data     节点数据
     * @return 是否添加成功
     */
    public boolean watchNodePersistentAndCreate(String path, Watcher userWatcher, String data) {
        return watchNodePersistent(path, userWatcher, data);
    }
    
    /**
     * 可持续监听子节点变化并自动创建节点
     *
     * @param path     节点路径
     * @param userWatcher 用户自定义监听器
     * @param data     节点数据
     * @return 是否添加成功
     */
    public boolean watchChildrenPersistentAndCreate(String path, Watcher userWatcher, String data) {
        return watchChildrenPersistent(path, userWatcher, data);
    }
    
    /**
     * 可持续监听节点变化并自动创建空节点
     *
     * @param path     节点路径
     * @param userWatcher 用户自定义监听器
     * @return 是否添加成功
     */
    public boolean watchNodePersistentAndCreateEmpty(String path, Watcher userWatcher) {
        return watchNodePersistent(path, userWatcher, "");
    }
    
    /**
     * 可持续监听子节点变化并自动创建空节点
     *
     * @param path     节点路径
     * @param userWatcher 用户自定义监听器
     * @return 是否添加成功
     */
    public boolean watchChildrenPersistentAndCreateEmpty(String path, Watcher userWatcher) {
        return watchChildrenPersistent(path, userWatcher, "");
    }
    
    // ==================== 监听器管理方法 ====================
    
    /**
     * 移除可持续节点监听器
     *
     * @param path 节点路径
     * @return 是否移除成功
     */
    public boolean removePersistentNodeWatcher(String path) {
        return watcherManager != null && watcherManager.removePersistentNodeWatcher(path);
    }
    
    /**
     * 移除可持续子节点监听器
     *
     * @param path 节点路径
     * @return 是否移除成功
     */
    public boolean removePersistentChildrenWatcher(String path) {
        return watcherManager != null && watcherManager.removePersistentChildrenWatcher(path);
    }
    
    /**
     * 移除所有可持续监听器
     */
    public void removeAllPersistentWatchers() {
        if (watcherManager != null) {
            watcherManager.removeAllPersistentWatchers();
        }
    }
    
    /**
     * 获取当前可持续监听器数量
     *
     * @return 监听器数量
     */
    public int getPersistentWatcherCount() {
        return watcherManager != null ? watcherManager.getPersistentWatcherCount() : 0;
    }
    
    // ==================== 向后兼容方法已移除 ====================
    // 为了保持 API 清晰，所有 @Deprecated 方法已被删除
    // 请使用新的明确命名的方法：
    // - watchXxxOneTime() 用于一次性监听
    // - watchXxxPersistent() 用于可持续监听
    
    // ==================== 数据变化回调接口 ====================
    
    /**
     * 数据变化回调接口
     */
    @FunctionalInterface
    public interface DataChangeCallback {
        /**
         * 数据变化回调
         *
         * @param path 节点路径
         * @param oldData 旧数据
         * @param newData 新数据
         */
        void onDataChanged(String path, String oldData, String newData);
    }
    
    /**
     * 数据变化处理器接口（委托给监听器管理器）
     */
    public interface DataChangeHandler {
        /**
         * 数据变化回调
         *
         * @param path 节点路径
         * @param oldData 旧数据
         * @param newData 新数据
         */
        void onDataChanged(String path, String oldData, String newData);
        
        /**
         * 获取上次的数据
         *
         * @return 上次的数据
         */
        default String getLastData() {
            return null;
        }
        
        /**
         * 设置数据缓存
         *
         * @param data 数据
         */
        default void setLastData(String data) {
            // 默认实现为空，子类可以重写
        }
    }
    
    // ==================== 便捷方法 ====================
    
    /**
     * 添加节点监听器并自动创建节点（便捷方法）
     *
     * @param path     节点路径
     * @param watcher  监听器
     * @param data     节点数据
     * @return 是否添加成功
     */
    public boolean watchAndCreate(String path, Watcher watcher, String data) {
        return addWatcher(path, watcher, data);
    }
    
    /**
     * 添加子节点监听器并自动创建节点（便捷方法）
     *
     * @param path     节点路径
     * @param watcher  监听器
     * @param data     节点数据
     * @return 是否添加成功
     */
    public boolean watchChildrenAndCreate(String path, Watcher watcher, String data) {
        return addChildrenWatcher(path, watcher, data);
    }
    
    /**
     * 添加节点监听器并自动创建空节点（便捷方法）
     *
     * @param path     节点路径
     * @param watcher  监听器
     * @return 是否添加成功
     */
    public boolean watchAndCreateEmpty(String path, Watcher watcher) {
        return addWatcher(path, watcher, "");
    }
    
    /**
     * 添加子节点监听器并自动创建空节点（便捷方法）
     *
     * @param path     节点路径
     * @param watcher  监听器
     * @return 是否添加成功
     */
    public boolean watchChildrenAndCreateEmpty(String path, Watcher watcher) {
        return addChildrenWatcher(path, watcher, "");
    }
    
    // ==================== 可持续监听便捷方法 ====================
    
    /**
     * 添加可持续节点监听器（便捷方法）
     *
     * @param path     节点路径
     * @param userWatcher 用户自定义监听器
     * @return 是否添加成功
     */
    public boolean addPersistentNodeWatcher(String path, Watcher userWatcher) {
        return watchNodePersistent(path, userWatcher, "");
    }
    
    /**
     * 添加可持续子节点监听器（便捷方法）
     *
     * @param path     节点路径
     * @param userWatcher 用户自定义监听器
     * @return 是否添加成功
     */
    public boolean addPersistentChildrenWatcher(String path, Watcher userWatcher) {
        return watchChildrenPersistent(path, userWatcher, "");
    }
    
    /**
     * 添加子节点变化监听器（如果节点不存在则创建）
     *
     * @param path     节点路径
     * @param watcher  监听器
     * @param data     节点数据（如果节点不存在时创建）
     * @return 是否添加成功
     */
    public boolean addChildrenWatcher(String path, Watcher watcher, String data) {
        if (!isConnected()) {
            log.error("Zookeeper 未连接");
            return false;
        }
        
        try {
            // 获取子节点列表并添加监听器
            List<String> children = zooKeeper.getChildren(path, watcher);
            log.info("子节点监听器添加成功: {}, 当前子节点数量: {}", path, children.size());
            return true;
            
        } catch (KeeperException.NoNodeException e) {
            log.info("节点不存在，自动创建节点: {}", path);
            // 节点不存在，自动创建
            if (createNodeRecursive(path, data)) {
                try {
                    // 重新添加监听器
                    List<String> children = zooKeeper.getChildren(path, watcher);
                    log.info("节点创建成功，子节点监听器添加成功: {}, 当前子节点数量: {}", path, children.size());
                    return true;
                } catch (Exception ex) {
                    log.error("重新添加子节点监听器失败: {}", path, ex);
                    return false;
                }
            } else {
                log.error("节点创建失败，无法添加子节点监听器: {}", path);
                return false;
            }
        } catch (Exception e) {
            log.error("添加子节点监听器失败: {}", path, e);
            return false;
        }
    }
    
    /**
     * 添加节点监听器
     *
     * @param path     节点路径
     * @param watcher  监听器
     * @return 是否添加成功
     */
    public boolean addWatcher(String path, Watcher watcher) {
        return addWatcher(path, watcher, "");
    }
    
    /**
     * 添加节点监听器（如果节点不存在则创建）
     *
     * @param path     节点路径
     * @param watcher  监听器
     * @param data     节点数据（如果节点不存在时创建）
     * @return 是否添加成功
     */
    public boolean addWatcher(String path, Watcher watcher, String data) {
        if (!isConnected()) {
            log.error("Zookeeper 未连接");
            return false;
        }
        
        try {
            // 检查节点是否存在
            Stat stat = zooKeeper.exists(path, watcher);
            if (stat == null) {
                log.info("节点不存在，自动创建节点: {}", path);
                // 节点不存在，自动创建
                if (createNodeRecursive(path, data)) {
                    log.info("节点创建成功，监听器添加成功: {}", path);
                    return true;
                } else {
                    log.error("节点创建失败，无法添加监听器: {}", path);
                    return false;
                }
            }
            
            log.info("节点监听器添加成功: {}", path);
            return true;
            
        } catch (Exception e) {
            log.error("添加节点监听器失败: {}", path, e);
            return false;
        }
    }
    
    /**
     * 添加子节点变化监听器
     *
     * @param path     节点路径
     * @param watcher  监听器
     * @return 是否添加成功
     */
    public boolean addChildrenWatcher(String path, Watcher watcher) {
        return addChildrenWatcher(path, watcher, "");
    }

}
